PC User 2004 August/Disc 1/PCU0804CD1.iso/software/browsers/files/opera1.exe/OPERA.JAR/com/opera/OperaInputStream.class

Java Class File | 2004-02-12 | 4.0 KB | 206 lines

package com.opera;

import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.util.Enumeration;
import java.util.Hashtable;

public class OperaInputStream extends InputStream {
   private static final int BUFFER_SIZE = 32768;
   private static Hashtable stream_map = new Hashtable();
   private static int next_stream_id = 0;
   private int protocol_response = -1;
   private byte[] buffer = new byte['ΦÇÇ'];
   private int next_read = 0;
   private int last_avail = -1;
   private int available = 0;
   private int total_input = 0;
   private int content_len = -1;
   private int stream_id = -1;
   private boolean header_loaded = false;
   private boolean eof_state = false;
   protected Hashtable header_fields = new Hashtable();

   protected OperaInputStream() {
   }

   public int getResponse() {
      return this.protocol_response;
   }

   public int available() {
      synchronized(this) {
         return this.available;
      }
   }

   public int read() throws IOException {
      synchronized(this) {
         while(this.available == 0 && !this.eof_state) {
            try {
               this.starving();
               this.wait();
            } catch (InterruptedException var4) {
               this.eof_state = true;
               this.available = 0;
               Thread.currentThread().interrupt();
               throw new InterruptedIOException();
            }
         }

         if (this.available == 0 && this.eof_state) {
            this.buffer = null;
            return -1;
         } else {
            --this.available;
            if (this.next_read == 32768) {
               this.next_read = 0;
            }

            return 255 & this.buffer[this.next_read++];
         }
      }
   }

   public void headerLoaded(int var1, int var2) {
      synchronized(this) {
         if (var1 == 0) {
            var1 = -1;
         }

         this.content_len = var1;
         this.protocol_response = var2;
         this.header_loaded = true;
         this.notifyAll();
      }
   }

   public int getContentLength() {
      synchronized(this) {
         while(!this.header_loaded) {
            try {
               this.wait();
            } catch (InterruptedException var4) {
            }
         }

         return this.content_len;
      }
   }

   public void setEOF() {
      synchronized(this) {
         this.eof_state = true;
         this.notifyAll();
      }
   }

   void signalStream() {
      synchronized(this) {
         this.notifyAll();
      }
   }

   public int addInput(byte[] var1) {
      int var2 = 0;
      int var3 = 0;
      synchronized(this) {
         try {
            if (this.eof_state) {
               this.notifyAll();
               byte var10000 = -1;
               return var10000;
            }

            if (var1.length > 0 && this.available < 32768) {
               int var5 = 'ΦÇÇ' - this.available;
               if (this.last_avail < 32767) {
                  if (var1.length < 'ΦÇÇ' - this.last_avail) {
                     var2 = var1.length;
                  } else {
                     var2 = 'ΦÇÇ' - this.last_avail - 1;
                  }

                  if (var2 > var5) {
                     var2 = var5;
                  }

                  System.arraycopy(var1, 0, this.buffer, this.last_avail + 1, var2);
               }

               var5 -= var2;
               if (var5 > 0) {
                  if (var1.length - var2 > var5) {
                     var3 = var5;
                  } else {
                     var3 = var1.length - var2;
                  }

                  System.arraycopy(var1, var2, this.buffer, 0, var3);
               }

               this.last_avail = (this.last_avail + var2 + var3) % 'ΦÇÇ';
            }

            this.notifyAll();
         } catch (ArrayIndexOutOfBoundsException var7) {
            var7.printStackTrace(System.err);
         }

         this.available += var2 + var3;
         this.total_input += var2 + var3;
         return var2 + var3;
      }
   }

   protected static int addStream(OperaInputStream var0) {
      synchronized(stream_map) {
         stream_map.put(new Integer(next_stream_id), var0);
         var0.stream_id = next_stream_id++;
      }

      return var0.stream_id;
   }

   protected static void removeStream(int var0) {
      synchronized(stream_map) {
         stream_map.remove(new Integer(var0));
      }

      OperaOutputStream.removeStream(var0);
   }

   protected static OperaInputStream getStream(int var0) {
      synchronized(stream_map) {
         return (OperaInputStream)stream_map.get(new Integer(var0));
      }
   }

   private native void starving();

   private void addHeader(String var1, String var2) {
      this.header_fields.put(var1.toLowerCase(), var2);
   }

   protected static void signalStreams() {
      Enumeration var0 = stream_map.elements();

      while(var0.hasMoreElements()) {
         Object var1 = var0.nextElement();
         synchronized(var1) {
            var1.notifyAll();
         }
      }

   }

   protected boolean isHeaderLoaded() {
      return this.header_loaded;
   }

   private int writeReady() {
      return 'ΦÇÇ' - this.available;
   }
}